package cn.itsource.service.impl;

import cn.itsource.annotation.CaoYuPiCacheAdd;
import cn.itsource.domain.CourseType;
import cn.itsource.mapper.CourseTypeMapper;
import cn.itsource.result.JSONResult;
import cn.itsource.service.ICourseTypeService;
import cn.itsource.vo.CrumbsVo;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.baomidou.mybatisplus.service.impl.ServiceImpl;
import lombok.extern.slf4j.Slf4j;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * <p>
 * 课程目录 服务实现类
 * </p>
 *
 * @author fengluochen
 * @since 2022-11-12
 */
@Service
@Slf4j
public class CourseTypeServiceImpl extends ServiceImpl<CourseTypeMapper, CourseType> implements ICourseTypeService {
    @Resource
    private CourseTypeMapper courseTypeMapper;
    @Resource
    private RedisTemplate redisTemplate;
    public JSONResult treeData2() {
        //1.查询所有的集合
        List<CourseType> resultList = courseTypeMapper.selectList(null);
//        //2.建立这个集合
//        List<CourseType> courseTypes = new ArrayList<>();
//        long t1 = System.currentTimeMillis();
//        //3.判断这个集合的元素是否是根节点,是根节点自己返回,不是根节点,查父节点,并且将其设置进入父节点的孩子节点中
//        for (int i = 0; i < resultList.size(); i++) {
//            CourseType courseType = resultList.get(i);
//            if(courseType.getPid()==0){
//                courseTypes.add(courseType);
//            }else{
//                for (int k = 0; k < resultList.size(); k++) {
//                    CourseType parentList = resultList.get(k);
//                    //判断是否是父节点
//                    if(parentList.getId().longValue()==courseType.getPid().longValue()){
//                        parentList.getChildren().add(courseType);
//                    }
//                }
//            }
//        }
//        long t2=System.currentTimeMillis();
//        long l = t2 - t1;
//        log.info("时间差={}",l);
        Long t1 = System.currentTimeMillis();
        Map<Long,CourseType> map1 = new HashMap<>();
        Map<Long,CourseType> map2 = new HashMap<>();
        List<CourseType> courseTypes = new ArrayList<>();
        for(CourseType t : resultList){
            if(t.getPid() == 0){
                map1.put(t.getId(),t);
                courseTypes.add(t);
            }else {
                if(map1.containsKey(t.getPid())){
                    map1.get(t.getPid()).getChildren().add(t);
                }
                if(map2.containsKey(t.getPid())){
                    map2.get(t.getPid()).getChildren().add(t);
                }else{
                    map2.put(t.getId(),t);
                }
            }
        }
        Long t2 = System.currentTimeMillis();
        System.out.println("版本2耗时=" + (t2-t1));
        return JSONResult.success(courseTypes);
    }
    //redis原生写
    public JSONResult treeData3() {
        //先从redis里面查有无courseTypes
        List<CourseType> courseTypes1 = (List<CourseType>) redisTemplate.opsForValue().get("courseTypes");
        //判断courstypes1是否有值,有就返回没有就查数据库
        if(courseTypes1!=null&&courseTypes1.size()>0){
            log.info("从redis里面拿");
            return JSONResult.success(courseTypes1);
        }else {
            //1.查询所有的集合
            log.info("从数据库里面拿");
            List<CourseType> resultList = courseTypeMapper.selectList(null);
            //2.建立这个集合
            List<CourseType> courseTypes = new ArrayList<>();
            long t1 = System.currentTimeMillis();
            //3.判断这个集合的元素是否是根节点,是根节点自己返回,不是根节点,查父节点,并且将其设置进入父节点的孩子节点中
            for (int i = 0; i < resultList.size(); i++) {
                CourseType courseType = resultList.get(i);
                if(courseType.getPid()==0){
                    courseTypes.add(courseType);
                }else{
                    for (int k = 0; k < resultList.size(); k++) {
                        CourseType parentList = resultList.get(k);
                        //判断是否是父节点
                        if(parentList.getId().longValue()==courseType.getPid().longValue()){
                            parentList.getChildren().add(courseType);
                        }
                    }
                }
            }
            long t2=System.currentTimeMillis();
            long l = t2 - t1;
            log.info("时间差={}",l);
            //设置redis
            redisTemplate.opsForValue().set("courseTypes",courseTypes);
            return JSONResult.success(courseTypes);
        }

    }
    //注解写
    @Override
   // @Cacheable(cacheNames = "course",key = "'courseTypes'")
    @CaoYuPiCacheAdd(cacheNames = "course", key = "treeData")
    public JSONResult treeData() {
            //1.查询所有的集合
            List<CourseType> resultList = courseTypeMapper.selectList(null);
            log.info("从数据库里面拿");
            //2.建立这个集合
            List<CourseType> courseTypes = new ArrayList<>();
            long t1 = System.currentTimeMillis();
            //3.判断这个集合的元素是否是根节点,是根节点自己返回,不是根节点,查父节点,并且将其设置进入父节点的孩子节点中
            for (int i = 0; i < resultList.size(); i++) {
                CourseType courseType = resultList.get(i);
                if(courseType.getPid()==0){
                    courseTypes.add(courseType);
                }else{
                    for (int k = 0; k < resultList.size(); k++) {
                        CourseType parentList = resultList.get(k);
                        //判断是否是父节点
                        if(parentList.getId().longValue()==courseType.getPid().longValue()){
                            parentList.getChildren().add(courseType);
                        }
                    }
                }
            }
            long t2=System.currentTimeMillis();
            long l = t2 - t1;
            log.info("时间差={}",l);
            return JSONResult.success(courseTypes);
        }

    @Override
    public JSONResult crumbs(Long courseTypeId) {
        //需要返回一个crumbs面包集合
        CrumbsVo crumbsVo = null;
        //1.新建一个crumbs集合
        ArrayList<CrumbsVo> crumbsVos = new ArrayList<>();
        //2.获取path路径 [1037,1038,1039]
        //查询数据
        CourseType courseType = courseTypeMapper.selectById(courseTypeId);
        String path = courseType.getPath();
        //分割数组
        String[] split = path.split("\\.");
        //3.获取里面每一个元素,设置进去
        for (int i = 0; i < split.length; i++) {
            String s = split[i];
            Long l = Long.valueOf(s);
            //查询数据
            CourseType courseType1 = courseTypeMapper.selectById(l);
            Wrapper<CourseType> wrapper = new EntityWrapper<>();

            wrapper.eq("pid",courseType1.getPid()).and().ne("id",l);
            List<CourseType> courseTypes = courseTypeMapper.selectList(wrapper);
            crumbsVo =new CrumbsVo();
            crumbsVo.setOwnerCourseType(courseType1);
            crumbsVo.setOtherCourseTypes(courseTypes);
            crumbsVos.add(crumbsVo);
        }
        //4.获取父id 查询父id里面所有子类并且删除自己
        //5.设置list
        //6,然后返回
        return JSONResult.success(crumbsVos);
    }


}
